'use strict';

/*
 *  集团/校区管理
 */ 
const mongoose = require('mongoose');
const classroomModel = require('../models/classroom.model');
const classgroupModel = require('../models/classgroup.model');
const classcampusModel = require('../models/classcampus.model');

const ipcModel = require('../models/ipc.model');
const httpUtil = require('../utils/http');
const Code = require('../common/error_code');
const Util = require('../utils/hobot_util');

// 集团列表
async function classgroup_list(ctx) {
    const params = ctx.request.body
    if(!params.page_size||!params.page_num){
        return ctx.error(Code.RET_USER_QUERY_ERR_PARAM);
    }
    let cdt = {
    };
    if (params.group_name) {
        cdt.group_name = { $regex: params.group_name };
    }
    if (params.num) {
        cdt.num = { $regex: params.num };
    }
    const classgroups = await Util.pageQuery(params.page_num, params.page_size, classgroupModel,
        cdt, '', '', {_id: -1});
    ctx.success(Code.REQUEST_SUCCESS('查询成功'), {
        page_num: params.page_num,
        page_size: params.page_size,
        total: classgroups.total,
        result: classgroups.results
    });
}

// 新增集团
async function add_classgroup(ctx){
    const params = ctx.request.body
    try{
        if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请补充参数'))
        if(!params.group_name){
            return ctx.error(Code.REQUEST_ERROR('请填写集团名称'))
        }
        const group_name = params.group_name
        const data = await classgroupModel.findOne({group_name})
        if(data){
            return ctx.error(Code.REQUEST_ERROR(`集团名：${group_name}已存在`))
        }
        const classgroup_newId = new mongoose.Types.ObjectId();
        const groupParams = {
            _id: classgroup_newId,
            group_name: group_name
        }
        await classgroupModel.create(groupParams)
        ctx.success(Code.REQUEST_SUCCESS('添加成功'))
    }catch(err){
        ctx.error(Code.REQUEST_ERROR('添加失败'))
    }
}

// 删除集团
async function delete_classgroup(ctx){
    const params = ctx.request.body
    try{
        if(!params || typeof params !=='object' || !params._id) return ctx.error(Code.REQUEST_ERROR('请选择要删除的教室'))
        const campusData = await classcampusModel.find({group_id:params._id})
        if(campusData&&campusData.length){
            return ctx.error(Code.REQUEST_ERROR('集团下存在绑定的校区无法直接删除'))
        }
        await classgroupModel.findOneAndRemove({_id:params._id})
        return ctx.success(Code.REQUEST_SUCCESS('删除成功'))
    }catch(err){
        return ctx.error(Code.REQUEST_ERROR('删除失败'))
    }
}

// 更新集团名称
async function update_classgroup(ctx){
    const params = ctx.request.body
    if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请补充参数'))
    if(!params._id){
        return ctx.error(Code.REQUEST_ERROR('请选择要更新的集团'))
    }
    if(!params.group_name){
        return ctx.error(Code.REQUEST_ERROR('请填写集团名称'))
    }
    try{
        const group_name = params.group_name
        const classgroup = await classgroupModel.findById(params._id)
        if(!classgroup){
            return ctx.error(Code.REQUEST_ERROR('该集团不存在'))
        }
        const data = await classgroupModel.findOne({
            group_name,
            _id:{
                $ne:params._id
            }
        })
        if(data){
            return ctx.error(Code.REQUEST_ERROR(`集团名：${group_name}已存在`))
        }
        await classgroupModel.findByIdAndUpdate(params._id, {
            group_name
        })
        ctx.success(Code.REQUEST_SUCCESS('更新成功'))
        await classcampusModel.updateMany({
            group_id:params._id,
        },{
            group_name
        })
        await classroomModel.updateMany({
            group_id:params._id,
        },{
            group_name
        })
        await ipcModel.updateMany({
            group_id:params._id,
        },{
            group_name
        })
    }catch(err){
        console.log(err)
        ctx.error(Code.REQUEST_ERROR('系统异常'))
    }
}

// 集团下的校区列表
async function classcampus_list(ctx) {
    const params = ctx.request.body
    if (!params.group_id) {
        return ctx.error(Code.REQUEST_ERROR('请选择关联的集团'))
    }
    const campusData = await classcampusModel.find({group_id:params.group_id})
    ctx.success(Code.REQUEST_SUCCESS('查询成功'), campusData);
}

// 添加校区
async function add_classcampus(ctx){
    const params = ctx.request.body
    try{
        if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请补充参数'))
        if(!params.campus_name){
            return ctx.error(Code.REQUEST_ERROR('请填写校区名称'))
        }
        if(!params.group_id){
            return ctx.error(Code.REQUEST_ERROR('请选择绑定集团'))
        }
        const classgroup = await classgroupModel.findById(params.group_id)
        if(!classgroup){
            return ctx.error(Code.REQUEST_ERROR('绑定的集团不存在'))
        }
        const group_name = classgroup.group_name
        const campus_name = params.campus_name
        const data = await classcampusModel.findOne({campus_name})
        if(data){
            return ctx.error(Code.REQUEST_ERROR(`校区名：${group_name}已存在`))
        }
        const classgcampus_newId = new mongoose.Types.ObjectId();
        const campusParams = {
            _id: classgcampus_newId,
            group_id:params.group_id,
            group_name: group_name,
            campus_name
        }
        await classcampusModel.create(campusParams)
        ctx.success(Code.REQUEST_SUCCESS('添加成功'))
    }catch(err){
        ctx.error(Code.REQUEST_ERROR('添加失败'))
    }
}

// 更新校区名称
async function update_classcampus(ctx){
    const params = ctx.request.body
    if(!params || typeof params !=='object') return ctx.error(Code.REQUEST_ERROR('请补充参数'))
    if(!params._id){
        return ctx.error(Code.REQUEST_ERROR('请选择要更新的校区'))
    }
    if(!params.campus_name){
        return ctx.error(Code.REQUEST_ERROR('请填写校区名称'))
    }
    const campus_name = params.campus_name
    const classcampus = await classcampusModel.findById(params._id)
    if(!classcampus){
        return ctx.error(Code.REQUEST_ERROR('该集团不存在'))
    }
    const data = await classcampusModel.findOne({
        campus_name,
        _id:{
            $ne: params._id
        }
    })
    if(data){
        return ctx.error(Code.REQUEST_ERROR(`校区名：${campus_name}已存在`))
    }
    await classcampusModel.findByIdAndUpdate(params._id, {
        campus_name
    })
    ctx.success(Code.REQUEST_SUCCESS('更新成功'))
    await classroomModel.updateMany({
        campus_id:params._id,
    },{
        campus_name
    })
    await ipcModel.updateMany({
        campus_id:params._id,
    },{
        campus_name
    })
}

// 删除校区
async function delete_classcampus(ctx){
    const params = ctx.request.body
    try{
        if(!params || typeof params !=='object' || !params._id) return ctx.error(Code.REQUEST_ERROR('请选择要删除的校区'))
        const roomData = await classroomModel.find({campus_id:params._id})
        if(roomData&&roomData.length){
            return ctx.error(Code.REQUEST_ERROR('校区下存在绑定的教室无法直接删除'))
        }
        await classcampusModel.findOneAndRemove({_id:params._id})
        return ctx.success(Code.REQUEST_SUCCESS('删除成功'))
    }catch(err){
        return ctx.error(Code.REQUEST_ERROR('删除失败'))
    }
}

exports.classgroup_list = classgroup_list
exports.add_classgroup = add_classgroup
exports.delete_classgroup = delete_classgroup
exports.update_classgroup = update_classgroup

exports.classcampus_list = classcampus_list
exports.add_classcampus = add_classcampus
exports.update_classcampus = update_classcampus
exports.delete_classcampus = delete_classcampus